home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / srcuc.zip / DOSSYS.C < prev    next >
C/C++ Source or Header  |  1992-05-05  |  9KB  |  369 lines
  1. /* -*-C-*-
  2.  
  3. $Header: /scheme/dos386/microcode/RCS/dossys.c,v 1.1 1992/05/05 06:55:13 jinx Exp $
  4.  
  5. Copyright (c) 1992 Massachusetts Institute of Technology
  6.  
  7. This material was developed by the Scheme project at the Massachusetts
  8. Institute of Technology, Department of Electrical Engineering and
  9. Computer Science.  Permission to copy this software, to redistribute
  10. it, and to use it for any purpose is granted, subject to the following
  11. restrictions and understandings.
  12.  
  13. 1. Any copy made of this software must include this copyright notice
  14. in full.
  15.  
  16. 2. Users of this software agree to make their best efforts (a) to
  17. return to the MIT Scheme project any improvements or extensions that
  18. they make, so that these may be included in future releases; and (b)
  19. to inform MIT of noteworthy uses of this software.
  20.  
  21. 3. All materials developed as a consequence of the use of this
  22. software shall duly acknowledge such use, in accordance with the usual
  23. standards of acknowledging credit in academic research.
  24.  
  25. 4. MIT has made no warrantee or representation that the operation of
  26. this software will be error-free, and MIT is under no obligation to
  27. provide any services, by way of maintenance, update, or otherwise.
  28.  
  29. 5. In conjunction with products arising from the use of this material,
  30. there shall be no use of the name of the Massachusetts Institute of
  31. Technology nor of any adaptation thereof in any advertising,
  32. promotional, or sales literature without prior written consent from
  33. MIT in each case. */
  34.  
  35. #include <dos.h>
  36. #include <stdio.h>
  37. #include "dossys.h"
  38.  
  39. int dos_keyboard_input_available_p(void)
  40. {
  41.   union REGS inregs, outregs;
  42.   
  43.   inregs.h.ah = 0x0B;
  44.   intdos(&inregs, &outregs);
  45.   
  46.   return (outregs.h.al != 0);
  47. }
  48.  
  49. unsigned char dos_get_keyboard_character(void)
  50. {
  51.   union REGS inregs, outregs;
  52.   
  53.   inregs.h.ah = 0x07;
  54.   intdos(&inregs, &outregs);
  55.   
  56.   return (unsigned char) (outregs.h.al);
  57. }
  58.  
  59. int dos_poll_keyboard_character(unsigned char *result)
  60. {
  61.   union REGS inregs, outregs;
  62.   
  63.   inregs.h.ah = 0x06;
  64.   inregs.h.dl = 0xFF;
  65.   intdos(&inregs, &outregs);
  66.   
  67.   *result = (unsigned char) (outregs.h.al);
  68.   return ((outregs.x.flags & 0x40) == 0);
  69. }
  70.  
  71. void dos_console_write_character(unsigned char character)
  72. {
  73.   union REGS inregs, outregs;
  74.   
  75.   inregs.h.ah = 0x06;
  76.   inregs.h.dl = character;
  77.   
  78.   intdos(&inregs, &outregs);
  79.   return;
  80. }
  81.  
  82. int dos_console_write(void * vbuffer, size_t nsize)
  83. { union REGS inregs, outregs;
  84.   unsigned char *buffer = vbuffer;
  85.   int i;  
  86.   
  87.   for (inregs.h.ah = 0x06, i=0; i < nsize; i++)
  88.   { inregs.h.dl = buffer[i];
  89.     intdos(&inregs, &outregs);
  90.   }
  91.   return nsize;
  92. }
  93.  
  94.  
  95. /* DOS I/O functions using handles */
  96.  
  97. handle_t dos_open_file_with_handle(unsigned char * name, int mode)
  98. {
  99.   union REGS inregs, outregs;
  100.   struct SREGS segregs;
  101.   
  102.   inregs.e.edx = (unsigned long) name;
  103.   segread(&segregs);
  104.  
  105.   inregs.h.ah = 0x3D;
  106.   inregs.h.al = mode;
  107.   intdosx(&inregs, &outregs, &segregs);
  108.   printf("Returning from DOS\n");
  109.   return (outregs.x.cflag) ? DOS_FAILURE : (unsigned int) outregs.x.ax;
  110. }
  111.  
  112. int dos_close_file_with_handle(handle_t handle)
  113. {
  114.   union REGS inregs, outregs;
  115.   
  116.   inregs.x.bx = handle;
  117.   inregs.h.al = 0x3E;
  118.   intdos(&inregs, &outregs);
  119.   
  120.   return (outregs.x.cflag) ? DOS_FAILURE : DOS_SUCCESS;
  121. }
  122.  
  123. int dos_read_file_with_handle(handle_t handle, void * buffer, size_t nbytes)
  124. {
  125.   union REGS inregs, outregs;
  126.   struct SREGS segregs;
  127.   
  128.   inregs.x.bx = handle;  
  129.   inregs.e.edx = (unsigned long) buffer;
  130.   inregs.e.ecx = nbytes;
  131.  
  132.   segread(&segregs);
  133.  
  134.   inregs.h.ah = 0x3F;
  135.   intdosx(&inregs, &outregs, &segregs);
  136.   
  137.   return (outregs.x.cflag) ? DOS_FAILURE : outregs.e.eax;
  138. }
  139.  
  140. int dos_write_file_with_handle(handle_t handle, void * buffer, size_t nbytes)
  141. {
  142.   union REGS inregs, outregs;
  143.   struct SREGS segregs;
  144.   
  145.   inregs.x.bx = handle;
  146.   inregs.e.edx = (unsigned long) buffer;
  147.   inregs.e.ecx = nbytes;
  148.   
  149.   segread(&segregs);
  150.  
  151.   inregs.h.ah = 0x40;
  152.   intdosx(&inregs, &outregs, &segregs);
  153.   
  154.   return (outregs.x.cflag) ? DOS_FAILURE : outregs.e.eax;
  155. }
  156.   
  157. int dos_get_device_status_with_handle(handle_t handle)
  158. { 
  159.   union REGS inregs, outregs;
  160.   
  161.   inregs.x.bx = handle;
  162.   inregs.x.ax = 0x4400;
  163.   intdos(&inregs, &outregs);
  164.   
  165.   return (outregs.x.cflag) ? DOS_FAILURE : (unsigned int) outregs.x.dx;
  166. }
  167.   
  168. int dos_set_device_status_with_handle(handle_t handle, int mode)
  169. { int original_mode;
  170.   union REGS inregs, outregs;
  171.   
  172.   original_mode = dos_get_device_status_with_handle(handle);
  173.   if (original_mode == DOS_FAILURE) return DOS_FAILURE;
  174.  
  175.   inregs.x.dx = mode;
  176.   inregs.x.bx = handle;
  177.   inregs.x.ax = 0x4401;
  178.   intdos(&inregs, &outregs);
  179.   return (outregs.x.cflag) ? DOS_FAILURE : original_mode;
  180. }  
  181.  
  182.  
  183.  
  184. void dos_get_version(version_t *version_number)
  185. {
  186.   union REGS inregs, outregs;
  187.  
  188.   /* Use old style version number because we may be running below DOS 5.0 */
  189.   inregs.h.al = 0x01;
  190.   inregs.h.ah = 0x30;
  191.   intdos(&inregs, &outregs);
  192.   version_number -> major = outregs.h.al;
  193.   version_number -> minor = outregs.h.ah;
  194.  
  195.   if ((version_number -> major) >= 5)
  196.   { /* Get the real version. */
  197.     inregs.x.ax = 0x3306;
  198.     intdos(&inregs, &outregs);
  199.     version_number -> major = outregs.h.bl;
  200.     version_number -> minor = outregs.h.bh;
  201.   }
  202.   return;
  203. }
  204.  
  205. void dos_reset_drive(void)
  206. {
  207.   union REGS inregs, outregs;
  208.   
  209.   inregs.h.al = 0x0d;
  210.   intdos(&inregs, &outregs);
  211.   
  212.   return;
  213. }
  214.  
  215. int dos_set_verify_flag(int verify_p)
  216. { union REGS inregs, outregs;
  217.   int old_flag;
  218.   
  219.   inregs.h.ah = 0x54;
  220.   intdos(&inregs, &outregs);
  221.   old_flag = outregs.h.al;
  222.   
  223.   inregs.h.al = (verify_p) ? 1 : 0;
  224.   inregs.h.ah = 0x2E;
  225.   intdos(&inregs, &outregs);
  226.   
  227.   return old_flag;
  228. }
  229.  
  230. int dos_set_ctrl_c_check_flag(int check_p)
  231. { union REGS inregs, outregs;
  232.   int old_flag;
  233.   
  234.   inregs.x.ax = 0x3300;
  235.   intdos(&inregs, &outregs);
  236.   old_flag = outregs.h.dl;
  237.   
  238.   inregs.h.dl = (check_p) ? 1 : 0;
  239.   inregs.x.ax = 0x3301;
  240.   intdos(&inregs, &outregs);
  241.   
  242.   return old_flag;
  243. }
  244.  
  245. int dos_rename_file(const char *old, const char *new)
  246. {
  247.   union REGS inregs, outregs;
  248.   struct SREGS segregs;
  249.   
  250.   inregs.e.edx = (unsigned long) old;
  251.   inregs.e.edi = (unsigned long) new;
  252.   segread(&segregs);
  253.   segregs.es = segregs.ds;
  254.  
  255.   inregs.h.ah = 0x56;
  256.   intdosx(&inregs, &outregs, &segregs);
  257.   
  258.   if (outregs.x.cflag)
  259.     return DOS_FAILURE;
  260.   else
  261.     return DOS_SUCCESS;
  262. }
  263.  
  264. int dos_get_machine_name(char *name)
  265. {
  266.   union REGS inregs, outregs;
  267.   struct SREGS segregs;
  268.   
  269.   inregs.e.edx = (unsigned long) name;
  270.   segregs.ds = getDS();
  271.  
  272.   inregs.x.ax = 0x5E00;
  273.   intdosx(&inregs, &outregs, &segregs);
  274.   
  275.   if ((outregs.x.cflag) || (outregs.h.ch == 0))
  276.     return DOS_FAILURE;
  277.   else
  278.     return outregs.h.cl;
  279. }
  280.  
  281. int dos_drive_letter_to_number(char letter)
  282. {
  283.   if (letter == '\0')
  284.     return 0;
  285.   else if ((letter >= 'a')&&(letter <= 'z'))
  286.     return ((letter - 'a') + 1);
  287.   else if ((letter >= 'A')&&(letter <= 'Z'))
  288.     return ((letter - 'A') + 1);
  289.   else
  290.     return -1;
  291. }
  292.  
  293. char dos_drive_number_to_letter(int number)
  294. {
  295.   if ((number >= 1)&&(number <= 26))
  296.     return ('A' + (number - 1));
  297.   else
  298.     return '\0';
  299. }
  300.  
  301. int dos_set_default_drive(int drive_number)
  302. {
  303.   union REGS inregs, outregs;
  304.   
  305.   if (drive_number > 0)
  306.   {    
  307.     inregs.h.dl = drive_number - 1;
  308.     inregs.h.ah = 0x0E;
  309.     intdos(&inregs, &outregs);
  310.   }
  311.   return DOS_SUCCESS;
  312. }
  313.     
  314. int dos_get_default_drive(int drive_number)
  315. {
  316.   union REGS inregs, outregs;
  317.   
  318.   inregs.h.ah = 0x19;
  319.   intdos(&inregs, &outregs);
  320.   
  321.   return outregs.h.al + 1;
  322. }
  323.  
  324.  
  325. dos_boolean 
  326. dos_pathname_as_filename(char * name, char * buffer)
  327. { /* Returns whether directory encountered is top level */
  328.   unsigned int end_index = strlen(name) - 1;
  329.  
  330.   /* The runtime system comes down with a name that has a back slash
  331.      at the end.  This will choke DOS.
  332.    */
  333.   strcpy(buffer, name);
  334.   if ((end_index >= 0) && (buffer[end_index] == '\\'))
  335.   { /* Name is indeed a directory */
  336.     if (end_index == 0) /* if only one char, name is top */
  337.       return dos_true;
  338.     else
  339.     { if (buffer[end_index-1] == ':') /* Preceded by drive letter, top */
  340.       { return dos_true; }
  341.       else
  342.       { buffer[end_index] = '\0';
  343.     return dos_false;
  344.       }
  345.     }
  346.   }
  347.   else
  348.   { return dos_false; }
  349. }
  350.  
  351. int dos_split_filename(char * name, char * device, char * filename)
  352. { 
  353.   unsigned start;
  354.   int drive_number;
  355.   
  356.   if ((strlen(name) >= 2) && (name[1] == ':'))
  357.   { device[0] = name[0], device[1] = name[1], device[2] = '\0';
  358.     drive_number = dos_drive_letter_to_number(name[0]);
  359.     start = 2;
  360.   }
  361.   else
  362.   { device[0] = '\0';
  363.     drive_number = 0;
  364.     start = 0;
  365.   }
  366.   dos_pathname_as_filename(&name[start], filename);
  367.   return drive_number;
  368. }
  369.